home *** CD-ROM | disk | FTP | other *** search
/ Maclife 157 / MACLIFE157-2001-09.ISO.7z / MACLIFE157-2001-09.ISO / Linux / MacOS Tools / Other / BootX 1.1.3 (for Old Mac OS) / Sources / lib / From MoreFiles / FileCopy.c < prev    next >
Text File  |  2001-07-23  |  19KB  |  594 lines
  1. /*
  2. **    Apple Macintosh Developer Technical Support
  3. **
  4. **    FileCopy: A robust, general purpose file copy routine.
  5. **
  6. **    by Jim Luther, Apple Developer Technical Support Emeritus
  7. **
  8. **    File:        FileCopy.c
  9. **
  10. **    Copyright ｩ 1992-1998 Apple Computer, Inc.
  11. **    All rights reserved.
  12. **
  13. **    You may incorporate this sample code into your applications without
  14. **    restriction, though the sample code has been provided "AS IS" and the
  15. **    responsibility for its operation is 100% yours.  However, what you are
  16. **    not permitted to do is to redistribute the source as "DSC Sample Code"
  17. **    after having made changes. If you're going to re-distribute the source,
  18. **    we require that you make it clear in the source that the code was
  19. **    descended from Apple Sample Code, but that you've made changes.
  20. */
  21.  
  22. #include <Types.h>
  23. #include <Errors.h>
  24. #include <Memory.h>
  25. #include <Files.h>
  26.  
  27. #define    __COMPILINGMOREFILES
  28.  
  29. #include "MoreFiles.h"
  30. #include "MoreFilesExtras.h"
  31. #include "MoreDesktopMgr.h"
  32. #include "FileCopy.h"
  33.  
  34. /*****************************************************************************/
  35.  
  36. /* local constants */
  37.  
  38. /*    The deny-mode privileges to use when opening the source and destination files. */
  39.  
  40. enum
  41. {
  42.     srcCopyMode = dmRdDenyWr,
  43.     dstCopyMode = dmWrDenyRdWr
  44. };
  45.  
  46. /*    The largest (16K) and smallest (.5K) copy buffer to use if the caller doesn't supply 
  47. **    their own copy buffer. */
  48.  
  49. enum
  50. {
  51.     bigCopyBuffSize  = 0x00004000,
  52.     minCopyBuffSize  = 0x00000200
  53. };
  54.  
  55. /*****************************************************************************/
  56.  
  57. /* static prototypes */
  58.  
  59. static    OSErr    GetDestinationDirInfo(short vRefNum,
  60.                                       long dirID,
  61.                                       ConstStr255Param name,
  62.                                       long *theDirID,
  63.                                       Boolean *isDirectory,
  64.                                       Boolean *isDropBox);
  65. /*    GetDestinationDirInfo tells us if the destination is a directory, it's
  66.     directory ID, and if it's an AppleShare drop box (write privileges only --
  67.     no read or search privileges).
  68.     vRefNum        input:    Volume specification.
  69.     dirID        input:    Directory ID.
  70.     name        input:    Pointer to object name, or nil when dirID
  71.                         specifies a directory that's the object.
  72.     theDirID    output:    If the object is a file, then its parent directory
  73.                         ID. If the object is a directory, then its ID.
  74.     isDirectory    output:    True if object is a directory; false if
  75.                         object is a file.
  76.     isDropBox    output:    True if directory is an AppleShare drop box.
  77. */
  78.  
  79. static    OSErr    CheckForForks(short vRefNum,
  80.                               long dirID,
  81.                               ConstStr255Param name,
  82.                               Boolean *hasDataFork,
  83.                               Boolean *hasResourceFork);
  84. /*    CheckForForks tells us if there is a data or resource fork to copy.
  85.     vRefNum        input:    Volume specification of the file's current
  86.                             location.
  87.     dirID        input:    Directory ID of the file's current location.
  88.     name        input:    The name of the file.
  89. */
  90.  
  91. static    OSErr    PreflightFileCopySpace(short srcVRefNum,
  92.                                        long srcDirID,
  93.                                        ConstStr255Param srcName,
  94.                                        ConstStr255Param dstVolName,
  95.                                        short dstVRefNum,
  96.                                        Boolean *spaceOK);
  97. /*    PreflightFileCopySpace determines if there's enough space on a
  98.     volume to copy the specified file to that volume.
  99.     Note: The results of this routine are not perfect. For example if the
  100.     volume's catalog or extents overflow file grows when the new file is
  101.     created, more allocation blocks may be needed beyond those needed for
  102.     the file's data and resource forks.
  103.  
  104.     srcVRefNum        input:    Volume specification of the file's current
  105.                             location.
  106.     srcDirID        input:    Directory ID of the file's current location.
  107.     srcName            input:    The name of the file.
  108.     dstVolName        input:    A pointer to the name of the volume where
  109.                             the file will be copied or NULL.
  110.     dstVRefNum        input:    Volume specification indicating the volume
  111.                             where the file will be copied.
  112.     spaceOK            output:    true if there's enough space on the volume for
  113.                             the file's data and resource forks.
  114. */
  115.  
  116. /*****************************************************************************/
  117.  
  118. static    OSErr    GetDestinationDirInfo(short vRefNum,
  119.                                       long dirID,
  120.                                       ConstStr255Param name,
  121.                                       long *theDirID,
  122.                                       Boolean *isDirectory,
  123.                                       Boolean *isDropBox)
  124. {
  125.     CInfoPBRec pb;
  126.     OSErr error;
  127.  
  128.     pb.dirInfo.ioACUser = 0;    /* ioACUser used to be filler2, clear it before calling GetCatInfo */
  129.     error = GetCatInfoNoName(vRefNum, dirID, name, &pb);
  130.     *theDirID = pb.dirInfo.ioDrDirID;
  131.     *isDirectory = (pb.dirInfo.ioFlAttrib & ioDirMask) != 0;
  132.     /* see if access priviledges are make changes, not see folder, and not see files (drop box) */
  133.     *isDropBox = ((pb.dirInfo.ioACUser & 0x07) == 0x03);
  134.     
  135.     return ( error );
  136. }
  137.  
  138. /*****************************************************************************/
  139.  
  140. static    OSErr    CheckForForks(short vRefNum,
  141.                               long dirID,
  142.                               ConstStr255Param name,
  143.                               Boolean *hasDataFork,
  144.                               Boolean *hasResourceFork)
  145. {
  146.     HParamBlockRec pb;
  147.     OSErr error;
  148.     
  149.     pb.fileParam.ioNamePtr = (StringPtr)name;
  150.     pb.fileParam.ioVRefNum = vRefNum;
  151.     pb.fileParam.ioFVersNum = 0;
  152.     pb.fileParam.ioDirID = dirID;
  153.     pb.fileParam.ioFDirIndex = 0;
  154.     error = PBHGetFInfoSync(&pb);
  155.     *hasDataFork = (pb.fileParam.ioFlLgLen != 0);
  156.     *hasResourceFork = (pb.fileParam.ioFlRLgLen != 0);
  157.     
  158.     return ( error );
  159. }
  160.  
  161. /*****************************************************************************/
  162.  
  163. static    OSErr    PreflightFileCopySpace(short srcVRefNum,
  164.                                        long srcDirID,
  165.                                        ConstStr255Param srcName,
  166.                                        ConstStr255Param dstVolName,
  167.                                        short dstVRefNum,
  168.                                        Boolean *spaceOK)
  169. {
  170.     UniversalFMPB pb;
  171.     OSErr error;
  172.     unsigned long dstFreeBlocks;
  173.     unsigned long dstBlksPerAllocBlk;
  174.     unsigned long srcDataBlks;
  175.     unsigned long srcResourceBlks;
  176.     
  177.     error = XGetVolumeInfoNoName(dstVolName, dstVRefNum, &pb.xPB);
  178.     if ( error == noErr )
  179.     {
  180.         /* get allocation block size (always multiple of 512) and divide by 512
  181.           to get number of 512-byte blocks per allocation block */
  182.         dstBlksPerAllocBlk = ((unsigned long)pb.xPB.ioVAlBlkSiz >> 9);
  183.         
  184.         /* Convert freeBytes to free disk blocks (512-byte blocks) */
  185.         dstFreeBlocks = (pb.xPB.ioVFreeBytes.hi << 23) + (pb.xPB.ioVFreeBytes.lo >> 9);
  186.         
  187.         /* Now, get the size of the file's data resource forks */
  188.         pb.hPB.fileParam.ioNamePtr = (StringPtr)srcName;
  189.         pb.hPB.fileParam.ioVRefNum = srcVRefNum;
  190.         pb.hPB.fileParam.ioFVersNum = 0;
  191.         pb.hPB.fileParam.ioDirID = srcDirID;
  192.         pb.hPB.fileParam.ioFDirIndex = 0;
  193.         error = PBHGetFInfoSync(&pb.hPB);
  194.         if ( error == noErr )
  195.         {
  196.             /* Since space on Mac OS disks is always allocated in allocation blocks, */
  197.             /* this code takes into account rounding up to the end of an allocation block. */
  198.  
  199.             /* get number of 512-byte blocks needed for data fork */
  200.             if ( ((unsigned long)pb.hPB.fileParam.ioFlLgLen & 0x000001ff) != 0 )
  201.             {
  202.                 srcDataBlks = ((unsigned long)pb.hPB.fileParam.ioFlLgLen >> 9) + 1;
  203.             }
  204.             else
  205.             {
  206.                 srcDataBlks = (unsigned long)pb.hPB.fileParam.ioFlLgLen >> 9;
  207.             }
  208.             
  209.             /* now, calculate number of new allocation blocks needed */
  210.             if ( srcDataBlks % dstBlksPerAllocBlk )
  211.             {
  212.                 srcDataBlks = (srcDataBlks / dstBlksPerAllocBlk) + 1;
  213.             }
  214.             else
  215.             {
  216.                 srcDataBlks /= dstBlksPerAllocBlk;
  217.             }
  218.         
  219.             /* get number of 512-byte blocks needed for resource fork */
  220.             if ( ((unsigned long)pb.hPB.fileParam.ioFlRLgLen & 0x000001ff) != 0 )
  221.             {
  222.                 srcResourceBlks = ((unsigned long)pb.hPB.fileParam.ioFlRLgLen >> 9) + 1;
  223.             }
  224.             else
  225.             {
  226.                 srcResourceBlks = (unsigned long)pb.hPB.fileParam.ioFlRLgLen >> 9;
  227.             }
  228.  
  229.             /* now, calculate number of new allocation blocks needed */
  230.             if ( srcResourceBlks % dstBlksPerAllocBlk )
  231.             {
  232.                 srcResourceBlks = (srcResourceBlks / dstBlksPerAllocBlk) + 1;
  233.             }
  234.             else
  235.             {
  236.                 srcResourceBlks /= dstBlksPerAllocBlk;
  237.             }
  238.             
  239.             /* Is there enough room on the destination volume for the source file? */
  240.             *spaceOK = ( ((srcDataBlks + srcResourceBlks) * dstBlksPerAllocBlk) <= dstFreeBlocks );
  241.         }
  242.     }
  243.     
  244.     return ( error );
  245. }
  246.  
  247. /*****************************************************************************/
  248.  
  249. pascal    OSErr    FileCopy(short srcVRefNum,
  250.                          long srcDirID,
  251.                          ConstStr255Param srcName,
  252.                          short dstVRefNum,
  253.                          long dstDirID,
  254.                          ConstStr255Param dstPathname,
  255.                          ConstStr255Param copyName,
  256.                          void *copyBufferPtr,
  257.                          long copyBufferSize,
  258.                          Boolean preflight)
  259. {
  260.     OSErr    err;
  261.  
  262.     short    srcRefNum = 0,            /* 0 when source data and resource fork are closed  */
  263.             dstDataRefNum = 0,        /* 0 when destination data fork is closed */
  264.             dstRsrcRefNum = 0;        /* 0 when destination resource fork is closed */
  265.     
  266.     Str63    dstName;                /* The filename of the destination. It might be the
  267.                                     ** source filename, it might be a new name... */
  268.     
  269.     GetVolParmsInfoBuffer infoBuffer; /* Where PBGetVolParms dumps its info */
  270.     long    srcServerAdr;            /* AppleTalk server address of source (if any) */
  271.     
  272.     Boolean    dstCreated = false,        /* true when destination file has been created */
  273.             ourCopyBuffer = false,    /* true if we had to allocate the copy buffer */
  274.             isDirectory,            /* true if destination is really a directory */
  275.             isDropBox;                /* true if destination is an AppleShare drop box */
  276.     
  277.     long    tempLong;
  278.     short    tempInt;
  279.     
  280.     Boolean    spaceOK;                /* true if there's enough room to copy the file to the destination volume */
  281.  
  282.     Boolean    hasDataFork;
  283.     Boolean    hasResourceFork;
  284.  
  285.     /* Preflight for size */
  286.     if ( preflight )
  287.     {
  288.         err = PreflightFileCopySpace(srcVRefNum, srcDirID, srcName,
  289.                                      dstPathname, dstVRefNum, &spaceOK);
  290.         if ( err != noErr )
  291.         {
  292.             return ( err );
  293.         }
  294.         
  295.         if ( !spaceOK )
  296.         {
  297.             return ( dskFulErr );
  298.         }
  299.     }
  300.  
  301.     /* get the destination's real dirID and make sure it really is a directory */
  302.     err = GetDestinationDirInfo(dstVRefNum, dstDirID, dstPathname,
  303.                                 &dstDirID, &isDirectory, &isDropBox);
  304.     if ( err != noErr )
  305.     {
  306.         goto ErrorExit;
  307.     }
  308.     
  309.     if ( !isDirectory )
  310.     {
  311.         return ( dirNFErr );
  312.     }
  313.  
  314.     /* get the destination's real vRefNum */
  315.     err = DetermineVRefNum(dstPathname, dstVRefNum, &dstVRefNum);
  316.     if ( err != noErr )
  317.     {
  318.         goto ErrorExit;
  319.     }
  320.     
  321.     /* See if PBHCopyFile can be used.  Using PBHCopyFile saves time by letting the file server
  322.     ** copy the file if the source and destination locations are on the same file server. */
  323.     tempLong = sizeof(infoBuffer);
  324.     err = HGetVolParms(srcName, srcVRefNum, &infoBuffer, &tempLong);
  325.     if ( (err != noErr) && (err != paramErr) )
  326.     {
  327.         return ( err );
  328.     }
  329.  
  330.     if ( (err != paramErr) && hasCopyFile(infoBuffer) )
  331.     {
  332.         /* The source volume supports PBHCopyFile. */
  333.         srcServerAdr = infoBuffer.vMServerAdr;
  334.  
  335.         /* Now, see if the destination volume is on the same file server. */
  336.         tempLong = sizeof(infoBuffer);
  337.         err = HGetVolParms(NULL, dstVRefNum, &infoBuffer, &tempLong);
  338.         if ( (err != noErr) && (err != paramErr) )
  339.         {
  340.             return ( err );
  341.         }
  342.         if ( (err != paramErr) && (srcServerAdr == infoBuffer.vMServerAdr) )
  343.         {
  344.             /* Source and Dest are on same server and PBHCopyFile is supported. Copy with CopyFile. */
  345.             err = HCopyFile(srcVRefNum, srcDirID, srcName, dstVRefNum, dstDirID, NULL, copyName);
  346.             if ( err != noErr )
  347.             {
  348.                 return ( err );
  349.             }
  350.                         
  351.             /* AppleShare's CopyFile clears the isAlias bit, so I still need to attempt to copy
  352.                the File's attributes to attempt to get things right. */
  353.             if ( copyName != NULL )                /* Did caller supply copy file name? */
  354.             {
  355.                 /* Yes, use the caller supplied copy file name. */
  356.                 (void) CopyFileMgrAttributes(srcVRefNum, srcDirID, srcName,
  357.                                              dstVRefNum, dstDirID, copyName, true);
  358.             }
  359.             else
  360.             {
  361.                 /* They didn't, so get the source file name and use it. */
  362.                 if ( GetFilenameFromPathname(srcName, dstName) == noErr )
  363.                 {
  364.                     /* */
  365.                     (void) CopyFileMgrAttributes(srcVRefNum, srcDirID, srcName,
  366.                                                  dstVRefNum, dstDirID, dstName, true);
  367.                 }
  368.             }
  369.             return ( err );
  370.         }
  371.     }
  372.  
  373.     /* If we're here, then PBHCopyFile couldn't be used so we have to copy the file by hand. */
  374.  
  375.     /* Make sure a copy buffer is allocated. */
  376.     if ( copyBufferPtr == NULL )
  377.     {
  378.         /* The caller didn't supply a copy buffer so grab one from the application heap.
  379.         ** Try to get a big copy buffer, if we can't, try for a 512-byte buffer.
  380.         ** If 512 bytes aren't available, we're in trouble. */
  381.         copyBufferSize = bigCopyBuffSize;
  382.         copyBufferPtr = NewPtr(copyBufferSize);
  383.         if ( copyBufferPtr == NULL )
  384.         {
  385.             copyBufferSize = minCopyBuffSize;
  386.             copyBufferPtr = NewPtr(copyBufferSize);
  387.             if ( copyBufferPtr == NULL )
  388.             {
  389.                 return ( memFullErr );
  390.             }
  391.         }
  392.         ourCopyBuffer = true;
  393.     }
  394.  
  395.     /* Open the source data fork. */
  396.     err = HOpenAware(srcVRefNum, srcDirID, srcName, srcCopyMode, &srcRefNum);
  397.     if ( err != noErr )
  398.         return ( err );
  399.     
  400.     /* Once a file is opened, we have to exit via ErrorExit to make sure things are cleaned up */
  401.     
  402.     /* See if the copy will be renamed. */
  403.     if ( copyName != NULL )                /* Did caller supply copy file name? */
  404.         BlockMoveData(copyName, dstName, copyName[0] + 1);    /* Yes, use the caller supplied copy file name. */
  405.     else
  406.     {    /* They didn't, so get the source file name and use it. */
  407.         err = GetFileLocation(srcRefNum, &tempInt, &tempLong, dstName);
  408.         if ( err != noErr )
  409.         {
  410.             goto ErrorExit;
  411.         }
  412.     }
  413.  
  414.     /* Create the destination file. */
  415.     err = HCreateMinimum(dstVRefNum, dstDirID, dstName);
  416.     if ( err != noErr )
  417.     {
  418.         goto ErrorExit;
  419.     }
  420.     dstCreated = true;    /* After creating the destination file, any
  421.                         ** error conditions should delete the destination file */
  422.  
  423.     /* An AppleShare dropbox folder is a folder for which the user has the Make Changes
  424.     ** privilege (write access), but not See Files (read access) and See Folders (search access).
  425.     ** Copying a file into an AppleShare dropbox presents some special problems. Here are the
  426.     ** rules we have to follow to copy a file into a dropbox:
  427.     ** ･ File attributes can be changed only when both forks of a file are empty.
  428.     ** ･ DeskTop Manager comments can be added to a file only when both forks of a file 
  429.     **   are empty.
  430.     ** ･ A fork can be opened for write access only when both forks of a file are empty.
  431.     ** So, with those rules to live with, we'll do those operations now while both forks
  432.     ** are empty. */
  433.  
  434.     if ( isDropBox )
  435.     {
  436.         /* We only set the file attributes now if the file is being copied into a
  437.         ** drop box. In all other cases, it is better to set the attributes last
  438.         ** so that if FileCopy is modified to give up time to other processes
  439.         ** periodicly, the Finder won't try to read any bundle information (because
  440.         ** the bundle-bit will still be clear) from a partially copied file. If the
  441.         ** copy is into a drop box, we have to set the attributes now, but since the
  442.         ** destination forks are opened with write/deny-read/deny-write permissions,
  443.         ** any Finder that might see the file in the drop box won't be able to open
  444.         ** its resource fork until the resource fork is closed.
  445.         **
  446.         ** Note: if you do modify FileCopy to give up time to other processes, don't
  447.         ** give up time between the time the destination file is created (above) and
  448.         ** the time both forks are opened (below). That way, you stand the best chance
  449.         ** of making sure the Finder doesn't read a partially copied resource fork.
  450.         */
  451.         /* Copy attributes but don't lock the destination. */
  452.         err = CopyFileMgrAttributes(srcVRefNum, srcDirID, srcName,
  453.                                     dstVRefNum, dstDirID, dstName, false);
  454.         if ( err != noErr )
  455.         {
  456.             goto ErrorExit;
  457.         }
  458.     }
  459.  
  460.     /* Attempt to copy the comments while both forks are empty.
  461.     ** Ignore the result because we really don't care if it worked or not. */
  462.     (void) DTCopyComment(srcVRefNum, srcDirID, srcName, dstVRefNum, dstDirID, dstName);
  463.  
  464.     /* See which forks we need to copy. By doing this, we won't create a data or resource fork
  465.     ** for the destination unless it's really needed (some foreign file systems such as
  466.     ** the ProDOS File System and Macintosh PC Exchange have to create additional disk
  467.     ** structures to support resource forks). */
  468.     err = CheckForForks(srcVRefNum, srcDirID, srcName, &hasDataFork, &hasResourceFork);
  469.     if ( err != noErr )
  470.     {
  471.         goto ErrorExit;
  472.     }
  473.     
  474.     if ( hasDataFork )
  475.     {
  476.         /* Open the destination data fork. */
  477.         err = HOpenAware(dstVRefNum, dstDirID, dstName, dstCopyMode, &dstDataRefNum);
  478.         if ( err != noErr )
  479.         {
  480.             goto ErrorExit;
  481.         }
  482.     }
  483.  
  484.     if ( hasResourceFork )
  485.     {
  486.         /* Open the destination resource fork. */
  487.         err = HOpenRFAware(dstVRefNum, dstDirID, dstName, dstCopyMode, &dstRsrcRefNum);
  488.         if ( err != noErr )
  489.         {
  490.             goto ErrorExit;
  491.         }
  492.     }
  493.  
  494.     if ( hasDataFork )
  495.     {
  496.         /* Copy the data fork. */
  497.         err = CopyFork(srcRefNum, dstDataRefNum, copyBufferPtr, copyBufferSize);
  498.         if ( err != noErr )
  499.         {
  500.             goto ErrorExit;
  501.         }
  502.     
  503.         /* Close both data forks and clear reference numbers. */
  504.         (void) FSClose(srcRefNum);
  505.         (void) FSClose(dstDataRefNum);
  506.         srcRefNum = dstDataRefNum = 0;
  507.     }
  508.     else
  509.     {
  510.         /* Close the source data fork since it was opened earlier */
  511.         (void) FSClose(srcRefNum);
  512.         srcRefNum = 0;
  513.     }
  514.  
  515.     if ( hasResourceFork )
  516.     {
  517.         /* Open the source resource fork. */
  518.         err = HOpenRFAware(srcVRefNum, srcDirID, srcName, srcCopyMode, &srcRefNum);
  519.         if ( err != noErr )
  520.         {
  521.             goto ErrorExit;
  522.         }
  523.     
  524.         /* Copy the resource fork. */
  525.         err = CopyFork(srcRefNum, dstRsrcRefNum, copyBufferPtr, copyBufferSize);
  526.         if ( err != noErr )
  527.         {
  528.             goto ErrorExit;
  529.         }
  530.     
  531.         /* Close both resource forks and clear reference numbers. */
  532.         (void) FSClose(srcRefNum);
  533.         (void) FSClose(dstRsrcRefNum);
  534.         srcRefNum = dstRsrcRefNum = 0;
  535.     }
  536.  
  537.     /* Get rid of the copy buffer if we allocated it. */
  538.     if ( ourCopyBuffer )
  539.     {
  540.         DisposePtr((Ptr)copyBufferPtr);
  541.     }
  542.  
  543.     /* Attempt to copy attributes again to set mod date.  Copy lock condition this time
  544.     ** since we're done with the copy operation.  This operation will fail if we're copying
  545.     ** into an AppleShare dropbox, so we don't check for error conditions. */
  546.     CopyFileMgrAttributes(srcVRefNum, srcDirID, srcName,
  547.                             dstVRefNum, dstDirID, dstName, true);
  548.  
  549.     /* Hey, we did it! */
  550.     return ( noErr );
  551.     
  552. ErrorExit:
  553.     if ( srcRefNum != 0 )
  554.     {
  555.         (void) FSClose(srcRefNum);        /* Close the source file */
  556.     }
  557.     if ( dstDataRefNum != 0 )
  558.     {
  559.         (void) FSClose(dstDataRefNum);    /* Close the destination file data fork */
  560.     }
  561.     if ( dstRsrcRefNum != 0 )
  562.     {
  563.         (void) FSClose(dstRsrcRefNum);    /* Close the destination file resource fork */
  564.     }
  565.     if ( dstCreated )
  566.     {
  567.         (void) HDelete(dstVRefNum, dstDirID, dstName);    /* Delete dest file.  This may fail if the file 
  568.                                                    is in a "drop folder" */
  569.     }
  570.     if ( ourCopyBuffer )    /* dispose of any memory we allocated */
  571.     {
  572.         DisposePtr((Ptr)copyBufferPtr);
  573.     }
  574.     
  575.     return ( err );
  576. }
  577.  
  578. /*****************************************************************************/
  579.  
  580. pascal    OSErr    FSpFileCopy(const FSSpec *srcSpec,
  581.                             const FSSpec *dstSpec,
  582.                             ConstStr255Param copyName,
  583.                             void *copyBufferPtr,
  584.                             long copyBufferSize,
  585.                             Boolean preflight)
  586. {
  587.     return ( FileCopy(srcSpec->vRefNum, srcSpec->parID, srcSpec->name,
  588.                      dstSpec->vRefNum, dstSpec->parID, dstSpec->name,
  589.                      copyName, copyBufferPtr, copyBufferSize, preflight) );
  590. }
  591.  
  592. /*****************************************************************************/
  593.  
  594.